home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / lynx-2.4 / WWW / Library / Implementation / HTVMS_WaisUI.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-28  |  58.6 KB  |  2,433 lines
  1. /*                            HTVMS_WAISUI.c
  2. **
  3. **    Adaptation for Lynx by F.Macrides (macrides@sci.wfeb.edu)
  4. **
  5. **    30-May-1994 FM    Initial version.
  6. **
  7. /*----------------------------------------------------------------------*/
  8.  
  9. /*
  10. **    Routines originally from UI.c -- FM
  11. **
  12. **----------------------------------------------------------------------*/
  13. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  14.    No guarantees or restrictions.  See the readme file for the full standard
  15.    disclaimer.
  16.  
  17.    Brewster@think.com
  18. */
  19.  
  20. /* 
  21.  * this is a simple ui toolkit for building other ui's on top.
  22.  * -brewster
  23.  * 
  24.  * top level functions:
  25.  *   generate_search_apdu
  26.  *   generate_retrieval_apdu
  27.  *   interpret_message
  28.  *
  29.  */
  30.  
  31. /* to do:
  32.  *   generate multiple queries for long documents.
  33.  *     this will crash if the file being retrieved is larger than 100k.
  34.  *   do log_write()
  35.  *   
  36.  */
  37.  
  38. #include "HTUtils.h"
  39. #include "tcp.h"
  40. #include "HTVMS_WaisUI.h"
  41. #include "HTVMS_WaisProt.h"
  42. /*#include <stdio> included by HTUtils.h -- FM */
  43. #include <string.h>
  44. #include <ctype.h>
  45. #include <math.h>
  46. #include <stdarg.h>
  47.  
  48. #include "LYexit.h"
  49. #include "LYLeaks.h"
  50.  
  51. void
  52. log_write(s)
  53. char *s;
  54. {
  55.     return;
  56. }
  57.  
  58. /*----------------------------------------------------------------------*/
  59.  
  60. /* returns a pointer in the buffer of the first free byte.
  61.    if it overflows, then NULL is returned 
  62.  */
  63. char *
  64. generate_search_apdu(buff,
  65.              buff_len,
  66.              seed_words,
  67.              database_name,
  68.              docobjs,
  69.              maxDocsRetrieved)
  70. char* buff;     /* buffer to hold the apdu */
  71. long *buff_len;    /* length of the buffer changed to reflect new data written */
  72. char *seed_words;    /* string of the seed words */
  73. char *database_name;
  74. DocObj** docobjs;
  75. long maxDocsRetrieved;
  76. {
  77.   /* local variables */
  78.  
  79.   SearchAPDU *search3;
  80.   char  *end_ptr;
  81.   static char *database_names[2] = {"", 0};
  82.   any refID;
  83.   WAISSearch *query;
  84.   refID.size = 1;
  85.   refID.bytes = "3";
  86.  
  87.   database_names[0] = database_name;
  88.   query = makeWAISSearch(seed_words,
  89.                          docobjs, /* DocObjsPtr */
  90.                          0,
  91.                          1,     /* DateFactor */
  92.                          0,     /* BeginDateRange */
  93.                          0,     /* EndDateRange */
  94.                          maxDocsRetrieved
  95.                          );
  96.  
  97.   search3 = makeSearchAPDU(30, 
  98.                5000, /* should be large */
  99.                30,
  100.                            1,    /* replace indicator */
  101.                            "",    /* result set name */
  102.                            database_names, /* database name */   
  103.                            QT_RelevanceFeedbackQuery, /* query_type */
  104.                            0,   /* element name */
  105.                            NULL, /* reference ID */
  106.                            query);
  107.  
  108.   end_ptr = writeSearchAPDU(search3, buff, buff_len);
  109.  
  110.   CSTFreeWAISSearch(query);
  111.   freeSearchAPDU(search3);
  112.   return(end_ptr);
  113. }
  114.  
  115. /*----------------------------------------------------------------------*/
  116.  
  117. /* returns a pointer into the buffer of the next free byte.
  118.    if it overflowed, then NULL is returned
  119.  */
  120.  
  121. char *
  122. generate_retrieval_apdu(buff,
  123.             buff_len,
  124.             docID,
  125.             chunk_type,
  126.             start,
  127.             end,
  128.             type,
  129.             database_name)
  130. char *buff;
  131. long *buff_len;    /* length of the buffer changed to reflect new data written */
  132. any *docID;
  133. long chunk_type;
  134. long start;
  135. long end;
  136. char *type;
  137. char *database_name;
  138. {
  139.   SearchAPDU *search;
  140.   char  *end_ptr;
  141.  
  142.   static char *database_names[2];
  143.   static char *element_names[3];
  144.   any refID;
  145.  
  146.   DocObj *DocObjs[2];
  147.   any *query;            /* changed from char* by brewster */
  148.  
  149.   if(NULL == type)
  150.     type = s_strdup("TEXT");
  151.  
  152.   database_names[0] = database_name;
  153.   database_names[1] = NULL;
  154.  
  155.   element_names[0] = " ";
  156.   element_names[1] = ES_DocumentText;
  157.   element_names[2] = NULL;
  158.  
  159.   refID.size = 1;
  160.   refID.bytes = "3";
  161.   
  162.   switch(chunk_type){
  163.   case CT_line: 
  164.     DocObjs[0] = makeDocObjUsingLines(docID, type, start, end);
  165.     break;
  166.   case CT_byte:
  167.     DocObjs[0] = makeDocObjUsingBytes(docID, type, start, end);
  168.     break;
  169.   }
  170.   DocObjs[1] = NULL;
  171.  
  172.   query = makeWAISTextQuery(DocObjs);   
  173.   search = makeSearchAPDU( 10, 16, 15, 
  174.               1,    /* replace indicator */
  175.               "FOO", /* result set name */
  176.               database_names, /* database name */   
  177.               QT_TextRetrievalQuery, /* query_type */
  178.               element_names, /* element name */
  179.               &refID, /* reference ID */
  180.               query);
  181.   end_ptr = writeSearchAPDU(search, buff, buff_len);
  182.   CSTFreeWAISTextQuery(query);
  183.   freeSearchAPDU(search);
  184.   return(end_ptr);
  185. }
  186.  
  187. /*----------------------------------------------------------------------*/
  188.  
  189. /* this is a safe version of unix 'read' it does all the checking
  190.  * and looping necessary
  191.  * to those trying to modify the transport code to use non-UNIX streams:
  192.  *  This is the function to modify!
  193.  */
  194. long read_from_stream(d,buf,nbytes)
  195. int d;                /* this is the stream */
  196. char *buf;
  197. long nbytes;
  198. {
  199.   long didRead;
  200.   long toRead = nbytes;
  201.   long totalRead = 0;        /* paranoia */
  202.  
  203.   while (toRead > 0){
  204.     didRead = NETREAD (d, buf, (int)toRead);
  205.     if(didRead == HT_INTERRUPTED)
  206.       return(HT_INTERRUPTED);
  207.     if(didRead == -1)        /* error*/
  208.       return(-1);
  209.     if(didRead == 0)        /* eof */
  210.       return(-2);        /* maybe this should return 0? */
  211.     toRead -= didRead;
  212.     buf += didRead;
  213.     totalRead += didRead;
  214.   }
  215.   if(totalRead != nbytes)    /* we overread for some reason */
  216.     return(- totalRead);    /* bad news */    
  217.   return(totalRead);
  218. }
  219.  
  220. /*----------------------------------------------------------------------*/
  221.  
  222. /* returns the length of the response, 0 if an error */
  223.  
  224. long 
  225. transport_message(connection,
  226.           request_message,
  227.           request_length,
  228.           response_message,
  229.           response_buffer_length)
  230. int connection;
  231. char *request_message;
  232. long request_length;
  233. char *response_message;
  234. long response_buffer_length;
  235. {
  236.   WAISMessage header;
  237.   long response_length;
  238.   int rv;
  239.  
  240.   
  241.   /* Write out message. Read back header. Figure out response length. */
  242.   
  243.   if( request_length + HEADER_LENGTH !=
  244.       NETWRITE(connection,request_message,
  245.              (int)( request_length +HEADER_LENGTH)) )
  246.     return 0;
  247.  
  248.   /* read for the first '0' */
  249.  
  250.   while(1){
  251.     rv = read_from_stream(connection, response_message, 1);
  252.     if (rv == HT_INTERRUPTED)
  253.       return HT_INTERRUPTED;
  254.     if (rv < 0)
  255.       return 0;
  256.     if('0' == response_message[0])
  257.       break;
  258.   }
  259.  
  260.   rv = read_from_stream(connection, response_message + 1, HEADER_LENGTH -1);
  261.   if (rv == HT_INTERRUPTED)
  262.     return HT_INTERRUPTED;
  263.   if (rv < 0)
  264.     return 0;
  265.  
  266.   readWAISPacketHeader(response_message, &header);
  267.   {
  268.     char length_array[11];
  269.     strncpy(length_array, header.msg_len, 10);
  270.     length_array[10] = '\0';
  271.     response_length = atol(length_array);
  272.     /*
  273.       if(verbose){
  274.       printf("WAIS header: '%s' length_array: '%s'\n", 
  275.       response_message, length_array);
  276.       }
  277.       */
  278.     if(response_length > response_buffer_length){
  279.       /* we got a message that is too long, therefore empty the message out,
  280.      and return 0 */
  281.       long i;
  282.       for(i = 0; i < response_length; i++){
  283.     rv = read_from_stream(connection, 
  284.                   response_message + HEADER_LENGTH,
  285.                   1);
  286.     if (rv == HT_INTERRUPTED)
  287.       return HT_INTERRUPTED;
  288.     if (rv < 0)
  289.       return 0;
  290.       }
  291.       return(0);
  292.     }
  293.   }
  294.   rv = read_from_stream(connection, 
  295.             response_message + HEADER_LENGTH,
  296.             response_length);
  297.   if (rv == HT_INTERRUPTED)
  298.     return HT_INTERRUPTED;
  299.   if (rv < 0)
  300.     return 0;
  301.   return(response_length);
  302. }
  303.  
  304. /*----------------------------------------------------------------------*/
  305.  
  306. /* returns the number of bytes writen.  0 if an error */
  307. long
  308. interpret_message(request_message,request_length,
  309.           response_message,
  310.           response_buffer_length,
  311.           connection,
  312.           verbose)
  313. char *request_message;
  314. long request_length; /* length of the buffer */
  315. char *response_message;
  316. long response_buffer_length;
  317. int connection;
  318. boolean verbose;
  319. {
  320.   long response_length;
  321.  
  322.   /* ?
  323.   if(verbose){
  324.     printf ("sending");
  325.     if(hostname_internal && strlen(hostname_internal) > 0)
  326.       printf(" to host %s", hostname_internal);
  327.     if(service_name && strlen(service_name) > 0)
  328.       printf(" for service %s", service_name);
  329.     printf("\n");
  330.     twais_dsply_rsp_apdu(request_message + HEADER_LENGTH, 
  331.              request_length);
  332.   }
  333.  
  334.   */
  335.  
  336.   writeWAISPacketHeader(request_message,
  337.             request_length,
  338.             (long)'z',    /* Z39.50 */
  339.             "wais      ", /* server name */
  340.             (long)NO_COMPRESSION,    /* no compression */
  341.             (long)NO_ENCODING,(long)HEADER_VERSION);
  342.   if(connection != 0) {
  343.     response_length = transport_message(connection, request_message,
  344.                     request_length,
  345.                     response_message,
  346.                     response_buffer_length);
  347.     if (response_length == HT_INTERRUPTED)
  348.       return(HT_INTERRUPTED);
  349.   }
  350.   else
  351.       return(0);
  352.  
  353.   return(response_length);
  354. }
  355.  
  356. /*----------------------------------------------------------------------*/
  357.  
  358. /* modifies the string to exclude all seeker codes. sets length to
  359.    the new length. */
  360. char *delete_seeker_codes(string,length)
  361. char *string;
  362. long *length;
  363. {
  364.   long original_count; /* index into the original string */
  365.   long new_count = 0; /* index into the collapsed string */
  366.   for(original_count = 0; original_count < *length; original_count++){
  367.     if(27 == string[original_count]){
  368.       /* then we have an escape code */
  369.       /* if the next letter is '(' or ')', then ignore two letters */
  370.       if('(' == string[original_count + 1] ||
  371.     ')' == string[original_count + 1])
  372.      original_count += 1;    /* it is a term marker */
  373.       else original_count += 4; /* it is a paragraph marker */
  374.     }
  375.     else string[new_count++] = string[original_count];
  376.   }
  377.   *length = new_count;
  378.   return(string);
  379. }
  380.   
  381. /*----------------------------------------------------------------------*/
  382.  
  383. /* returns a pointer to a string with good stuff */
  384. char *trim_junk(headline)
  385. char *headline;
  386. {
  387.   long length = strlen(headline) + 1; /* include the trailing null */
  388.   long i;
  389.   headline = delete_seeker_codes(headline, &length);
  390.   /* delete leading spaces */
  391.   for(i=0; i < strlen(headline); i++){
  392.     if(isprint(headline[i])){
  393.       break;
  394.     }
  395.   }
  396.   headline = headline + i;
  397.   /* delete trailing stuff */
  398.   for(i=strlen(headline) - 1 ; i > 0; i--){
  399.     if(isprint(headline[i])){
  400.       break;
  401.     }
  402.     headline[i] = '\0';
  403.   }
  404.   return(headline);
  405. }
  406.  
  407. /*----------------------------------------------------------------------*/
  408.  
  409.  
  410. /*
  411. **    Routines originally from ZProt.c -- FM
  412. **
  413. **----------------------------------------------------------------------*/
  414. /* WIDE AREA INFORMATION SERVER SOFTWARE:`
  415.    No guarantees or restrictions.  See the readme file for the full standard
  416.    disclaimer.    
  417.   
  418.    3.26.90    Harry Morris, morris@think.com
  419.    3.30.90  Harry Morris - Changed any->bits to any->bytes
  420.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  421. */
  422.  
  423. #define RESERVE_SPACE_FOR_HEADER(spaceLeft)        \
  424.     *spaceLeft -= HEADER_LEN;
  425.     
  426. #define RELEASE_HEADER_SPACE(spaceLeft)            \
  427.     if (*spaceLeft > 0)                \
  428.       *spaceLeft += HEADER_LEN;
  429.     
  430. /*----------------------------------------------------------------------*/
  431.  
  432. InitResponseAPDU* 
  433. makeInitResponseAPDU(result,
  434.              search,
  435.              present,
  436.              deleteIt,
  437.              accessControl,
  438.              resourceControl,
  439.              prefSize,
  440.              maxMsgSize,
  441.              auth,
  442.              id,
  443.              name,
  444.              version,
  445.              refID,
  446.              userInfo)
  447. boolean result;
  448. boolean search;
  449. boolean present;
  450. boolean deleteIt;
  451. boolean accessControl;
  452. boolean resourceControl;
  453. long prefSize;
  454. long maxMsgSize;
  455. char* auth;
  456. char* id;
  457. char* name;
  458. char* version;
  459. any* refID;
  460. void* userInfo;
  461. /* build an initResponse APDU with user specified information */
  462. { 
  463.   InitResponseAPDU* init = (InitResponseAPDU*)s_malloc((size_t)sizeof(InitResponseAPDU));
  464.  
  465.   init->PDUType = initResponseAPDU;
  466.   init->Result = result;
  467.   init->willSearch = search;
  468.   init->willPresent = present;
  469.   init->willDelete = deleteIt;
  470.   init->supportAccessControl = accessControl;
  471.   init->supportResourceControl = resourceControl;
  472.   init->PreferredMessageSize = prefSize;
  473.   init->MaximumRecordSize = maxMsgSize;
  474.   init->IDAuthentication = s_strdup(auth);
  475.   init->ImplementationID = s_strdup(id);
  476.   init->ImplementationName = s_strdup(name);
  477.   init->ImplementationVersion = s_strdup(version);
  478.   init->ReferenceID = duplicateAny(refID);
  479.   init->UserInformationField = userInfo; /* not copied! */
  480.   
  481.   return(init);
  482. }
  483.  
  484. /*----------------------------------------------------------------------*/
  485.  
  486. void 
  487. freeInitResponseAPDU(init)
  488. InitResponseAPDU* init;
  489. /* free an initAPDU */
  490. {
  491.   s_free(init->IDAuthentication);
  492.   s_free(init->ImplementationID);
  493.   s_free(init->ImplementationName);
  494.   s_free(init->ImplementationVersion);
  495.   freeAny(init->ReferenceID);
  496.   s_free(init);
  497. }
  498.  
  499. /*----------------------------------------------------------------------*/
  500.  
  501. char* 
  502. writeInitResponseAPDU(init,buffer,len)
  503. InitResponseAPDU* init;
  504. char* buffer;
  505. long* len;
  506. /* write the initResponse to a buffer, adding system information */
  507. { 
  508.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  509.   long size;
  510.   bit_map* optionsBM = NULL;
  511.  
  512.   RESERVE_SPACE_FOR_HEADER(len);
  513.   
  514.   buf = writePDUType(init->PDUType,buf,len);
  515.   buf = writeBoolean(init->Result,buf,len);
  516.   buf = writeProtocolVersion(buf,len);
  517.   
  518.   optionsBM = makeBitMap((unsigned long)5,init->willSearch,init->willPresent,
  519.                          init->willDelete,init->supportAccessControl,
  520.                          init->supportResourceControl);
  521.   buf = writeBitMap(optionsBM,DT_Options,buf,len);
  522.   freeBitMap(optionsBM);
  523.  
  524.   buf = writeNum(init->PreferredMessageSize,DT_PreferredMessageSize,buf,len);
  525.   buf = writeNum(init->MaximumRecordSize,DT_MaximumRecordSize,buf,len);
  526.   buf = writeString(init->IDAuthentication,DT_IDAuthentication,buf,len);
  527.   buf = writeString(init->ImplementationID,DT_ImplementationID,buf,len);
  528.   buf = writeString(init->ImplementationName,DT_ImplementationName,buf,len);
  529.   buf = writeString(init->ImplementationVersion,DT_ImplementationVersion,buf,len);
  530.   buf = writeAny(init->ReferenceID,DT_ReferenceID,buf,len);
  531.   
  532.   /* go back and write the header-length-indicator */
  533.   RELEASE_HEADER_SPACE(len);
  534.   size = buf - buffer - HEADER_LEN; 
  535.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  536.  
  537.   if (init->UserInformationField != NULL)
  538.     buf = writeInitResponseInfo(init,buf,len);   
  539.     
  540.   return(buf);
  541. }
  542.  
  543. /*----------------------------------------------------------------------*/
  544.  
  545. char* 
  546. readInitResponseAPDU(init,buffer)
  547. InitResponseAPDU** init;
  548. char* buffer;
  549. {
  550.   char* buf = buffer;
  551.   boolean search,present,delete,accessControl,resourceControl;
  552.   long prefSize,maxMsgSize;
  553.   char *auth,*id,*name,*version;
  554.   long size; 
  555.   pdu_type pduType;
  556.   bit_map* versionBM = NULL;
  557.   bit_map* optionsBM = NULL;
  558.   boolean result;
  559.   any *refID = NULL;
  560.   void* userInfo = NULL;
  561.   
  562.   auth = id = name = version = NULL;
  563.   refID = NULL;
  564.   
  565.   /* read required part */
  566.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  567.   buf = readPDUType(&pduType,buf);
  568.   buf = readBoolean(&result,buf);
  569.   buf = readBitMap(&versionBM,buf); 
  570.   buf = readBitMap(&optionsBM,buf);
  571.   buf = readNum(&prefSize,buf);
  572.   buf = readNum(&maxMsgSize,buf);
  573.   
  574.   /* decode optionsBM */
  575.   search = bitAtPos(0,optionsBM);
  576.   present = bitAtPos(1,optionsBM);
  577.   delete = bitAtPos(2,optionsBM);
  578.   accessControl = bitAtPos(3,optionsBM);
  579.   resourceControl = bitAtPos(4,optionsBM);
  580.   
  581.   /* read optional part */
  582.   while (buf < (buffer + size + HEADER_LEN)) 
  583.     { data_tag tag = peekTag(buf);
  584.       switch (tag)
  585.     { case DT_IDAuthentication:
  586.         buf = readString(&auth,buf);
  587.         break;
  588.       case DT_ImplementationID:
  589.         buf = readString(&id,buf);
  590.         break;
  591.       case DT_ImplementationName:
  592.         buf = readString(&name,buf);
  593.         break;
  594.       case DT_ImplementationVersion:
  595.         buf = readString(&version,buf);
  596.         break;
  597.       case DT_ReferenceID:
  598.         buf = readAny(&refID,buf);
  599.         break;
  600.       default:
  601.         freeBitMap(versionBM);
  602.         freeBitMap(optionsBM);
  603.         s_free(auth);
  604.         s_free(id);
  605.         s_free(name);
  606.         s_free(version);
  607.         freeAny(refID);
  608.         REPORT_READ_ERROR(buf);
  609.         break;
  610.       }
  611.     }
  612.  
  613.   buf = readInitResponseInfo(&userInfo,buf);
  614.   if (buf == NULL)
  615.     { freeBitMap(versionBM);
  616.       freeBitMap(optionsBM);
  617.       s_free(auth);
  618.       s_free(id);
  619.       s_free(name);
  620.       s_free(version);
  621.       freeAny(refID);
  622.     }
  623.   RETURN_ON_NULL(buf);
  624.   
  625.   /* construct the basic init object */
  626.   *init = makeInitResponseAPDU(result,
  627.                    search,present,delete,accessControl,resourceControl,
  628.                    prefSize,maxMsgSize,auth,id,name,version,refID,userInfo);
  629.                                           
  630.   freeBitMap(versionBM);
  631.   freeBitMap(optionsBM);
  632.   s_free(auth);
  633.   s_free(id);
  634.   s_free(name);
  635.   s_free(version);
  636.   freeAny(refID);
  637.   
  638.   return(buf);
  639. }
  640.  
  641. /*----------------------------------------------------------------------*/
  642.  
  643. InitResponseAPDU* 
  644. replyToInitAPDU(init,result,userInfo)
  645. InitAPDU* init;
  646. boolean result;
  647. void* userInfo;
  648. /* respond to an init message in the default way - echoing back
  649.    the init info 
  650.  */
  651. {
  652.   InitResponseAPDU* initResp;
  653.   initResp = makeInitResponseAPDU(result,
  654.                   init->willSearch,init->willPresent,init->willDelete,
  655.                   init->supportAccessControl,init->supportResourceControl,
  656.                   init->PreferredMessageSize,init->MaximumRecordSize,
  657.                   init->IDAuthentication,defaultImplementationID(),defaultImplementationName(),
  658.                   defaultImplementationVersion(),
  659.                   init->ReferenceID,userInfo);
  660.   return(initResp);
  661. }
  662.  
  663. /*----------------------------------------------------------------------*/
  664.  
  665. SearchAPDU* 
  666. makeSearchAPDU(small,
  667.            large,
  668.            medium,
  669.            replace,
  670.            name,
  671.            databases,
  672.            type,
  673.            elements,
  674.            refID,
  675.            queryInfo)
  676. long small;
  677. long large;
  678. long medium;
  679. boolean replace;
  680. char* name;
  681. char** databases;
  682. char* type;
  683. char** elements;
  684. any* refID;
  685. void* queryInfo;
  686. {
  687.   char* ptr = NULL;
  688.   long i;
  689.   SearchAPDU* query = (SearchAPDU*)s_malloc((size_t)sizeof(SearchAPDU));
  690.   query->PDUType = searchAPDU;
  691.   query->SmallSetUpperBound = small;
  692.   query->LargeSetLowerBound = large;
  693.   query->MediumSetPresentNumber = medium;
  694.   query->ReplaceIndicator = replace;
  695.   query->ResultSetName = s_strdup(name);
  696.   query->DatabaseNames = NULL; 
  697.   if (databases != NULL)
  698.     { for (i = 0, ptr = databases[i]; ptr != NULL; ptr = databases[++i])
  699.     { if (query->DatabaseNames == NULL)
  700.         query->DatabaseNames = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  701.         else
  702.           query->DatabaseNames = (char**)s_realloc((char*)query->DatabaseNames,
  703.                            (size_t)(sizeof(char*) * (i + 2)));
  704.         query->DatabaseNames[i] = s_strdup(ptr);
  705.         query->DatabaseNames[i+1] = NULL;
  706.       }
  707.       }
  708.   query->QueryType = s_strdup(type);
  709.   query->ElementSetNames = NULL; 
  710.   if (elements != NULL)
  711.     { for (i = 0, ptr = elements[i]; ptr != NULL; ptr = elements[++i])
  712.     { if (query->ElementSetNames == NULL)
  713.         query->ElementSetNames = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  714.         else
  715.           query->ElementSetNames = (char**)s_realloc((char*)query->ElementSetNames,
  716.                              (size_t)(sizeof(char*) * (i + 2)));
  717.         query->ElementSetNames[i] = s_strdup(ptr);
  718.         query->ElementSetNames[i+1] = NULL;
  719.       }
  720.       }
  721.   query->ReferenceID = duplicateAny(refID);
  722.   query->Query = queryInfo;    /* not copied! */
  723.   return(query);
  724. }
  725.  
  726. /*----------------------------------------------------------------------*/
  727.  
  728. void 
  729. freeSearchAPDU(query)
  730. SearchAPDU* query;
  731. {
  732.   s_free(query->ResultSetName);
  733.   s_free(query->QueryType);
  734.   doList((void**)query->DatabaseNames,fs_free); /* can't use the macro here ! */
  735.   s_free(query->DatabaseNames);
  736.   doList((void**)query->ElementSetNames,fs_free); /* can't use the macro here ! */
  737.   s_free(query->ElementSetNames);
  738.   freeAny(query->ReferenceID);
  739.   s_free(query);
  740. }
  741.  
  742. /*----------------------------------------------------------------------*/
  743.  
  744. #define DB_DELIMITER     "\037"     /* hex 1F occurs between each database name */
  745. #define ES_DELIMITER_1     "\037"     /* separates database name from element name */
  746. #define ES_DELIMITER_2     "\036"     /* hex 1E separates <db,es> groups from one another */
  747.  
  748. char* 
  749. writeSearchAPDU(query,buffer,len)
  750. SearchAPDU* query;
  751. char* buffer;
  752. long* len;
  753. { 
  754.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  755.   long size,i;
  756.   char* ptr = NULL;
  757.   char* scratch = NULL;
  758.  
  759.   RESERVE_SPACE_FOR_HEADER(len);
  760.   
  761.   buf = writePDUType(query->PDUType,buf,len);
  762.   buf = writeBinaryInteger(query->SmallSetUpperBound,(size_t)3,buf,len);
  763.   buf = writeBinaryInteger(query->LargeSetLowerBound,(size_t)3,buf,len);
  764.   buf = writeBinaryInteger(query->MediumSetPresentNumber,(size_t)3,buf,len);
  765.   buf = writeBoolean(query->ReplaceIndicator,buf,len);
  766.   buf = writeString(query->ResultSetName,DT_ResultSetName,buf,len);
  767.   /* write database names */
  768.   if (query->DatabaseNames != NULL)
  769.     { for (i = 0,scratch = NULL, ptr = query->DatabaseNames[i]; ptr != NULL; ptr = query->DatabaseNames[++i])
  770.     { if (scratch == NULL)
  771.         scratch = s_strdup(ptr);
  772.         else
  773.       { size_t newScratchSize = (size_t)(strlen(scratch) + strlen(ptr) + 2);
  774.         scratch = (char*)s_realloc(scratch,newScratchSize);
  775.         s_strncat(scratch,DB_DELIMITER,2,newScratchSize);
  776.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize);
  777.       }
  778.       }
  779.     buf = writeString(scratch,DT_DatabaseNames,buf,len);
  780.     s_free(scratch);
  781.       }
  782.   buf = writeString(query->QueryType,DT_QueryType,buf,len);
  783.   /* write element set names */
  784.   if (query->ElementSetNames != NULL)
  785.     { for (i = 0,scratch = NULL, ptr = query->ElementSetNames[i]; ptr != NULL; ptr = query->ElementSetNames[++i])
  786.     { if (scratch == NULL)
  787.         { if (query->ElementSetNames[i+1] == NULL) /* there is a single element set name */
  788.         { scratch = (char*)s_malloc((size_t)strlen(ptr) + 2);
  789.           strncpy(scratch,ES_DELIMITER_1,2);
  790.           s_strncat(scratch,ptr,strlen(ptr) + 1,strlen(ptr) + 2);
  791.         }
  792.         else        /* this is the first of a series of element set names */
  793.           { size_t newScratchSize = (size_t)(strlen(ptr) + strlen(query->ElementSetNames[i + 1]) + 2);
  794.         scratch = s_strdup(ptr); /* the database name */
  795.         ptr = query->ElementSetNames[++i]; /* the element set name */
  796.         scratch = (char*)s_realloc(scratch,newScratchSize);
  797.         s_strncat(scratch,ES_DELIMITER_1,2,newScratchSize);
  798.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize); 
  799.           }
  800.           }
  801.         else
  802.       { char* esPtr = query->ElementSetNames[++i]; /* the element set name */
  803.         size_t newScratchSize = (size_t)(strlen(scratch) + strlen(ptr) + strlen(esPtr) + 3);
  804.         scratch = (char*)s_realloc(scratch,newScratchSize);
  805.         s_strncat(scratch,ES_DELIMITER_2,2,newScratchSize);
  806.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize);
  807.         s_strncat(scratch,ES_DELIMITER_1,2,newScratchSize);
  808.         s_strncat(scratch,esPtr,strlen(esPtr) + 1,newScratchSize); 
  809.       }
  810.       }
  811.     buf = writeString(scratch,DT_ElementSetNames,buf,len);
  812.     s_free(scratch);
  813.       }                        
  814.   buf = writeAny(query->ReferenceID,DT_ReferenceID,buf,len);
  815.     
  816.   /* go back and write the header-length-indicator */
  817.   RELEASE_HEADER_SPACE(len);
  818.   size = buf - buffer - HEADER_LEN; 
  819.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  820.  
  821.   if (query->Query != NULL)
  822.     buf = writeSearchInfo(query,buf,len);    
  823.     
  824.   return(buf);
  825. }
  826.  
  827. /*----------------------------------------------------------------------*/
  828.  
  829. SearchResponseAPDU* 
  830. makeSearchResponseAPDU(result,count,recordsReturned,nextPos,resultStatus,
  831.                presentStatus,refID,records)
  832. long result;
  833. long count;
  834. long recordsReturned;
  835. long nextPos;
  836. long resultStatus;
  837. long presentStatus;
  838. any* refID;
  839. void* records;
  840. {
  841.   SearchResponseAPDU* query = (SearchResponseAPDU*)s_malloc((size_t)sizeof(SearchResponseAPDU));
  842.   query->PDUType = searchResponseAPDU;
  843.   query->SearchStatus = result;
  844.   query->ResultCount = count;
  845.   query->NumberOfRecordsReturned = recordsReturned;
  846.   query->NextResultSetPosition = nextPos;
  847.   query->ResultSetStatus = resultStatus;
  848.   query->PresentStatus = presentStatus;
  849.   query->ReferenceID = duplicateAny(refID);
  850.   query->DatabaseDiagnosticRecords = records;
  851.   return(query);  
  852. }
  853.  
  854. /*----------------------------------------------------------------------*/
  855.  
  856. void 
  857. freeSearchResponseAPDU(queryResponse)
  858. SearchResponseAPDU* queryResponse;
  859. {
  860.   freeAny(queryResponse->ReferenceID);
  861.   s_free(queryResponse);
  862. }
  863.  
  864. /*----------------------------------------------------------------------*/
  865.  
  866. char* 
  867. writeSearchResponseAPDU(queryResponse,buffer,len)
  868. SearchResponseAPDU* queryResponse;
  869. char* buffer;
  870. long* len;
  871. {
  872.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  873.   long size;
  874.  
  875.   RESERVE_SPACE_FOR_HEADER(len);
  876.   
  877.   buf = writePDUType(queryResponse->PDUType,buf,len);
  878.   buf = writeBinaryInteger(queryResponse->SearchStatus,(size_t)1,buf,len);
  879.   buf = writeBinaryInteger(queryResponse->ResultCount,(size_t)3,buf,len);
  880.   buf = writeBinaryInteger(queryResponse->NumberOfRecordsReturned,(size_t)3,buf,len);
  881.   buf = writeBinaryInteger(queryResponse->NextResultSetPosition,(size_t)3,buf,len);
  882.   buf = writeNum(queryResponse->ResultSetStatus,DT_ResultSetStatus,buf,len);
  883.   buf = writeNum(queryResponse->PresentStatus,DT_PresentStatus,buf,len);
  884.   buf = writeAny(queryResponse->ReferenceID,DT_ReferenceID,buf,len);
  885.     
  886.   /* go back and write the header-length-indicator */
  887.   RELEASE_HEADER_SPACE(len);
  888.   size = buf - buffer - HEADER_LEN; 
  889.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  890.  
  891.   if (queryResponse->DatabaseDiagnosticRecords != NULL)
  892.     buf = writeSearchResponseInfo(queryResponse,buf,len);    
  893.     
  894.   return(buf);
  895. }
  896.  
  897. /*----------------------------------------------------------------------*/
  898.  
  899. char* 
  900. readSearchResponseAPDU(queryResponse,buffer)
  901. SearchResponseAPDU** queryResponse;
  902. char* buffer;
  903. {
  904.   char* buf = buffer;
  905.   long size;
  906.   pdu_type pduType;
  907.   long result,count,recordsReturned,nextPos;
  908.   long resultStatus,presentStatus;
  909.   any *refID = NULL;
  910.   void* userInfo = NULL;
  911.   
  912.   /* read required part */
  913.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  914.   buf = readPDUType(&pduType,buf);
  915.   buf = readBinaryInteger(&result,(size_t)1,buf);
  916.   buf = readBinaryInteger(&count,(size_t)3,buf);
  917.   buf = readBinaryInteger(&recordsReturned,(size_t)3,buf);
  918.   buf = readBinaryInteger(&nextPos,(size_t)3,buf);
  919.   
  920.   resultStatus = presentStatus = UNUSED;
  921.   refID = NULL;
  922.  
  923.   /* read optional part */
  924.   while (buf < (buffer + size + HEADER_LEN)) 
  925.     { data_tag tag = peekTag(buf);
  926.       switch (tag)
  927.     { case DT_ResultSetStatus:
  928.         buf = readNum(&resultStatus,buf);
  929.         break;
  930.       case DT_PresentStatus:
  931.         buf = readNum(&presentStatus,buf);
  932.         break;
  933.       case DT_ReferenceID:
  934.         buf = readAny(&refID,buf);
  935.         break;
  936.       default:
  937.         freeAny(refID);
  938.         REPORT_READ_ERROR(buf);
  939.         break;
  940.       }
  941.     }
  942.   
  943.   buf = readSearchResponseInfo(&userInfo,buf);
  944.   if (buf == NULL)
  945.     freeAny(refID);
  946.   RETURN_ON_NULL(buf);
  947.   
  948.   /* construct the search object */
  949.   *queryResponse = makeSearchResponseAPDU(result,count,recordsReturned,nextPos,
  950.                       (long)resultStatus,(long)presentStatus,refID,userInfo);
  951.  
  952.   freeAny(refID);
  953.   
  954.   return(buf);
  955. }
  956.  
  957.  
  958. /*
  959. **    Routines originally from ZUtil.c -- FM
  960. **
  961. **----------------------------------------------------------------------*/
  962. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  963.    No guarantees or restrictions.  See the readme file for the full standard
  964.    disclaimer.    
  965.   
  966.    3.26.90    Harry Morris, morris@think.com
  967.    3.30.90  Harry Morris - Changed any->bits to any->bytes
  968.    4.11.90  HWM - fixed include file names, changed 
  969.                    - writeCompressedIntegerWithPadding() to
  970.                   writeCompressedIntWithPadding()
  971.                 - generalized conditional includes (see c-dialect.h)
  972.    3.7.91   Jonny Goldman.  Replaced "short" in makeBitMap with "int" line 632.
  973. */
  974.  
  975. char* readErrorPosition = NULL; /* pos where buf stoped making sense */
  976.  
  977. /*----------------------------------------------------------------------*/
  978. /* A note on error handling 
  979.    read - these are low level routines, they do not check the type tags
  980.    which (sometimes) preceed the data (this is done by the higher
  981.    level functions which call these functions).  There is no 
  982.    attempt made to check that the reading does not exceed the read
  983.    buffer.  Such cases should be very rare and usually will be 
  984.    caught by the calling functions. (note - it is unlikely that 
  985.    a series of low level reads will go far off the edge without
  986.    triggering a type error.  However, it is possible for a single
  987.    bad read in an array function (eg. readAny) to attempt to read a 
  988.    large ammount, possibly causing a segmentation violation or out
  989.    of memory condition.
  990.  */
  991. /*----------------------------------------------------------------------*/
  992.  
  993. diagnosticRecord* 
  994. makeDiag(surrogate,code,addInfo)
  995. boolean surrogate;
  996. char* code;
  997. char* addInfo;
  998. {
  999.   diagnosticRecord* diag = 
  1000.     (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord));
  1001.   
  1002.   diag->SURROGATE = surrogate;
  1003.   memcpy(diag->DIAG,code,DIAGNOSTIC_CODE_SIZE);
  1004.   diag->ADDINFO = s_strdup(addInfo); 
  1005.  
  1006.   return(diag);
  1007. }
  1008.  
  1009. /*----------------------------------------------------------------------*/
  1010.  
  1011. void 
  1012. freeDiag(diag)
  1013. diagnosticRecord* diag;
  1014. { 
  1015.   if (diag != NULL)
  1016.     { if (diag->ADDINFO != NULL)
  1017.     s_free(diag->ADDINFO);
  1018.     s_free(diag);
  1019.       }
  1020. }
  1021.  
  1022. /*----------------------------------------------------------------------*/
  1023.  
  1024. #define END_OF_RECORD    0x1D
  1025.  
  1026. char* 
  1027. writeDiag(diag,buffer,len)
  1028. diagnosticRecord* diag;
  1029. char* buffer;
  1030. long* len;
  1031. /* diagnostics (as per Appendix D) have a very weird format - this changes
  1032.    in SR-1
  1033.  */
  1034. {
  1035.   char* buf = buffer;
  1036.   long  length;
  1037.   
  1038.   if (diag == NULL)        /* handle unspecified optional args */
  1039.     return(buf);
  1040.  
  1041.   buf = writeTag(DT_DatabaseDiagnosticRecords,buf,len);
  1042.   CHECK_FOR_SPACE_LEFT(0,len);
  1043.   
  1044.   length = 3; 
  1045.   if (diag->ADDINFO != NULL)
  1046.     length += strlen(diag->ADDINFO);
  1047.     
  1048.   if (length >= 0xFFFF )    /* make sure the length is reasonable */
  1049.     { length = 0xFFFF - 1;
  1050.       diag->ADDINFO[0xFFFF - 3 - 1] = '\0';
  1051.     }
  1052.    
  1053.   buf = writeBinaryInteger(length,2,buf,len);
  1054.  
  1055.   CHECK_FOR_SPACE_LEFT(1,len);
  1056.   buf[0] = diag->DIAG[0]; 
  1057.   buf++;
  1058.   
  1059.   CHECK_FOR_SPACE_LEFT(1,len);
  1060.   buf[0] = diag->DIAG[1];
  1061.   buf++;
  1062.   
  1063.   if (length > 3)
  1064.     { CHECK_FOR_SPACE_LEFT(3,len);
  1065.       memcpy(buf,diag->ADDINFO,(size_t)length - 3);
  1066.       buf += length - 3;
  1067.     }
  1068.    
  1069.   CHECK_FOR_SPACE_LEFT(1,len);
  1070.   buf[0] = diag->SURROGATE;
  1071.   buf++;
  1072.   
  1073.   CHECK_FOR_SPACE_LEFT(1,len);
  1074.   buf[0] = END_OF_RECORD;
  1075.   buf++;
  1076.  
  1077.   return(buf);
  1078. }
  1079.  
  1080. /*----------------------------------------------------------------------*/
  1081.  
  1082. char* 
  1083. readDiag(diag,buffer)
  1084. diagnosticRecord** diag;
  1085. char* buffer;
  1086. {
  1087.   char* buf = buffer;
  1088.   diagnosticRecord* d 
  1089.     = (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord));
  1090.   data_tag tag;
  1091.   long len;
  1092.   
  1093.   buf = readTag(&tag,buf);
  1094.   
  1095.   buf = readBinaryInteger(&len,2,buf);
  1096.   
  1097.   d->DIAG[0] = buf[0];
  1098.   d->DIAG[1] = buf[1];
  1099.   d->DIAG[2] = '\0';
  1100.     
  1101.   if (len > 3)
  1102.     { d->ADDINFO = (char*)s_malloc((size_t)(len - 3 + 1));
  1103.       memcpy(d->ADDINFO,(char*)(buf + 2),(size_t)(len - 3));
  1104.       d->ADDINFO[len - 3] = '\0';
  1105.     }
  1106.   else
  1107.     d->ADDINFO = NULL;
  1108.     
  1109.   d->SURROGATE = buf[len - 1];
  1110.   
  1111.   *diag = d;
  1112.  
  1113.   return(buf + len + 1);
  1114. }
  1115.  
  1116. /*----------------------------------------------------------------------*/
  1117.  
  1118. #define continueBit    0x80
  1119. #define dataMask    0x7F
  1120. #define dataBits    7
  1121.  
  1122. char*
  1123. writeCompressedInteger(num,buf,len)
  1124. unsigned long num;
  1125. char* buf;
  1126. long* len;
  1127. /* write a binary integer in the format described on p. 40.
  1128.    this might be sped up 
  1129. */
  1130. {
  1131.   char byte;
  1132.   long i;
  1133.   unsigned long size;
  1134.   
  1135.   size = writtenCompressedIntSize(num);
  1136.   CHECK_FOR_SPACE_LEFT(size,len);
  1137.   
  1138.   for (i = size - 1; i >= 0; i--)
  1139.     { byte = num & dataMask;
  1140.       if (i != (size-1))    /* turn on continue bit */
  1141.     byte = (char)(byte | continueBit);
  1142.       buf[i] = byte;
  1143.       num = num >> dataBits;    /* don't and here */
  1144.     }
  1145.    
  1146.   return(buf + size);
  1147. } 
  1148.  
  1149. /*----------------------------------------------------------------------*/
  1150.  
  1151. char*
  1152. readCompressedInteger(num,buf)
  1153. unsigned long *num;
  1154. char* buf;
  1155. /* read a binary integer in the format described on p. 40.
  1156.    this might be sped up 
  1157. */
  1158. {
  1159.   long i = 0;
  1160.   unsigned char byte;
  1161.  
  1162.   *num = 0;
  1163.   
  1164.   do 
  1165.     { byte = buf[i++];
  1166.       *num = *num << dataBits;
  1167.       *num += (byte & dataMask);
  1168.     }
  1169.   while (byte & continueBit);
  1170.  
  1171.   return(buf + i);
  1172. } 
  1173.  
  1174. /*----------------------------------------------------------------------*/
  1175.  
  1176. #define pad    128 /* high bit is set */
  1177.  
  1178. char*
  1179. writeCompressedIntWithPadding(num,size,buffer,len)
  1180. unsigned long num;
  1181. unsigned long size;
  1182. char* buffer;
  1183. long* len;
  1184. /* Like writeCompressedInteger, except writes padding (128) to make
  1185.    sure that size bytes are used.  This can be read correctly by 
  1186.    readCompressedInteger()
  1187. */
  1188. {
  1189.   char* buf = buffer;
  1190.   unsigned long needed,padding;
  1191.   long i;
  1192.     
  1193.   CHECK_FOR_SPACE_LEFT(size,len);
  1194.   
  1195.   needed = writtenCompressedIntSize(num);
  1196.   padding = size - needed;
  1197.   i = padding - 1;
  1198.  
  1199.   for (i = padding - 1;i >= 0;i--)
  1200.     { buf[i] = pad;
  1201.     }
  1202.   
  1203.   buf = writeCompressedInteger(num,buf + padding,len);
  1204.   
  1205.   return(buf);
  1206. } 
  1207.  
  1208. /*----------------------------------------------------------------------*/
  1209.  
  1210. unsigned long
  1211. writtenCompressedIntSize(num)
  1212. unsigned long num;
  1213. /* return the number of bytes needed to represnet the value num in
  1214.    compressed format.  curently limited to 4 bytes
  1215.  */
  1216. {
  1217.   if (num < CompressedInt1Byte) 
  1218.     return(1);
  1219.   else if (num < CompressedInt2Byte) 
  1220.     return(2);
  1221.   else if (num < CompressedInt3Byte)
  1222.     return(3);
  1223.   else
  1224.     return(4);    
  1225. }
  1226.  
  1227. /*----------------------------------------------------------------------*/
  1228.  
  1229. char*
  1230. writeTag(tag,buf,len)
  1231. data_tag tag;
  1232. char* buf;
  1233. long* len;
  1234. /* write out a data tag */
  1235. { 
  1236.   return(writeCompressedInteger(tag,buf,len));
  1237. } 
  1238.  
  1239. /*----------------------------------------------------------------------*/
  1240.  
  1241. char*
  1242. readTag(tag,buf)
  1243. data_tag* tag;
  1244. char* buf;
  1245. /* read a data tag */
  1246. { 
  1247.   return(readCompressedInteger(tag,buf));
  1248. } 
  1249.  
  1250. /*----------------------------------------------------------------------*/
  1251.  
  1252. unsigned long 
  1253. writtenTagSize(tag)
  1254. data_tag tag;
  1255. { 
  1256.   return(writtenCompressedIntSize(tag));
  1257. }
  1258.  
  1259. /*----------------------------------------------------------------------*/
  1260.  
  1261. data_tag
  1262. peekTag(buf)
  1263. char* buf;
  1264. /* read a data tag without advancing the buffer */
  1265. {
  1266.   data_tag tag;
  1267.   readTag(&tag,buf);
  1268.   return(tag);
  1269. } 
  1270.  
  1271. /*----------------------------------------------------------------------*/
  1272.  
  1273. any* 
  1274. makeAny(size,data)
  1275. unsigned long size;
  1276. char* data;
  1277. {
  1278.   any* a = (any*)s_malloc((size_t)sizeof(any));
  1279.   a->size = size;
  1280.   a->bytes = data;
  1281.   return(a);
  1282. }
  1283.  
  1284. /*----------------------------------------------------------------------*/
  1285.  
  1286. void
  1287. freeAny(a)
  1288. any* a;
  1289. /* destroy an any and its associated data. Assumes a->bytes was
  1290.    allocated using the s_malloc family of libraries 
  1291.  */
  1292. {
  1293.   if (a != NULL)
  1294.     { if (a->bytes != NULL)
  1295.     s_free(a->bytes);
  1296.       s_free(a);
  1297.     }
  1298. }
  1299.  
  1300. /*----------------------------------------------------------------------*/
  1301.  
  1302. any* 
  1303. duplicateAny(a)
  1304. any* a;
  1305. {
  1306.   any* copy = NULL;
  1307.  
  1308.   if (a == NULL)
  1309.     return(NULL);
  1310.  
  1311.   copy = (any*)s_malloc((size_t)sizeof(any));
  1312.   copy->size = a->size;
  1313.   if (a->bytes == NULL)
  1314.     copy->bytes = NULL;
  1315.   else
  1316.     { copy->bytes = (char*)s_malloc((size_t)copy->size);
  1317.       memcpy(copy->bytes,a->bytes,(size_t)copy->size);
  1318.     }
  1319.   return(copy);
  1320. }
  1321.  
  1322. /*----------------------------------------------------------------------*/
  1323.  
  1324. char* 
  1325. writeAny(a,tag,buffer,len)
  1326. any* a;
  1327. data_tag tag;
  1328. char* buffer;
  1329. long* len;
  1330. /* write an any + tag and size info */
  1331. {
  1332.   char* buf = buffer;
  1333.  
  1334.   if (a == NULL)        /* handle unspecified optional args */
  1335.     return(buf);
  1336.   
  1337.   /* write the tags */
  1338.   buf = writeTag(tag,buf,len);
  1339.   buf = writeCompressedInteger(a->size,buf,len);
  1340.  
  1341.   /* write the bytes */
  1342.   CHECK_FOR_SPACE_LEFT(a->size,len);
  1343.   memcpy(buf,a->bytes,(size_t)a->size);
  1344.  
  1345.   return(buf+a->size);
  1346. }
  1347.  
  1348. /*----------------------------------------------------------------------*/
  1349.  
  1350.  
  1351. char *readAny(anAny,buffer)
  1352. any** anAny;
  1353. char* buffer;
  1354. /* read an any + tag and size info */
  1355. {
  1356.   char *buf;
  1357.   any* a;
  1358.   data_tag tag;
  1359.  
  1360.  
  1361.  
  1362. a=(any*)s_malloc((size_t)sizeof(any));
  1363.  
  1364.   buf=buffer;
  1365.   
  1366.   buf = readTag(&tag,buf);
  1367.   
  1368.   buf = readCompressedInteger(&a->size,buf);
  1369.  
  1370.   /* now simply copy the bytes */
  1371.   a->bytes = (char*)s_malloc((size_t)a->size);
  1372.   memcpy(a->bytes,buf,(size_t)a->size);
  1373.   *anAny = a;
  1374.  
  1375.   return(buf+a->size);
  1376. }
  1377.  
  1378. /*----------------------------------------------------------------------*/
  1379.  
  1380. unsigned long 
  1381. writtenAnySize(tag,a)
  1382. data_tag tag;
  1383. any* a;
  1384. {
  1385.   unsigned long size;
  1386.  
  1387.   if (a == NULL)
  1388.     return(0);
  1389.  
  1390.   size = writtenTagSize(tag);
  1391.   size += writtenCompressedIntSize(a->size);
  1392.   size += a->size;
  1393.   return(size);
  1394. }
  1395.  
  1396. /*----------------------------------------------------------------------*/
  1397.  
  1398. any*
  1399. stringToAny(s)
  1400. char* s;
  1401. {
  1402.   any* a = NULL;
  1403.   
  1404.   if (s == NULL)
  1405.     return(NULL);
  1406.     
  1407.   a = (any*)s_malloc((size_t)sizeof(any));
  1408.   a->size = strlen(s);
  1409.   a->bytes = (char*)s_malloc((size_t)a->size);
  1410.   memcpy(a->bytes,s,(size_t)a->size);
  1411.   return(a);
  1412. }
  1413.  
  1414. /*----------------------------------------------------------------------*/
  1415.  
  1416. char*
  1417. anyToString(a)
  1418. any* a;
  1419. {
  1420.   char* s = NULL;
  1421.   
  1422.   if (a == NULL)
  1423.     return(NULL);
  1424.     
  1425.   s = s_malloc((size_t)(a->size + 1));
  1426.   memcpy(s,a->bytes,(size_t)a->size);
  1427.   s[a->size] = '\0';
  1428.   return(s);
  1429. }
  1430.  
  1431. /*----------------------------------------------------------------------*/
  1432.  
  1433. char* 
  1434. writeString(s,tag,buffer,len)
  1435. char* s;
  1436. data_tag tag;
  1437. char* buffer;
  1438. long* len;
  1439. /* Write a C style string.  The terminating null is not written. 
  1440.    This function is not part of the Z39.50 spec.  It is provided
  1441.    for the convienience of those wishing to pass C strings in 
  1442.    the place of an any.
  1443.  */
  1444. {
  1445.   char* buf = buffer;
  1446.   any* data = NULL;
  1447.   if (s == NULL)
  1448.     return(buffer);        /* handle unused optional item before making an any */
  1449.   data = (any*)s_malloc((size_t)sizeof(any)); 
  1450.   data->size = strlen(s);
  1451.   data->bytes = s;        /* save a copy here by not using stringToAny() */
  1452.   buf = writeAny(data,tag,buf,len);
  1453.   s_free(data);            /* don't use freeAny() since it will free s too */
  1454.   return(buf);
  1455. }
  1456.  
  1457. /*----------------------------------------------------------------------*/
  1458.  
  1459. char* 
  1460. readString(s ,buffer)
  1461. char** s ;
  1462. char* buffer;
  1463. /* Read an any and convert it into a C style string.
  1464.    This function is not part of the Z39.50 spec.  It is provided
  1465.    for the convienience of those wishing to pass C strings in 
  1466.    the place of an any. 
  1467.  */
  1468. {
  1469.   any* data = NULL;
  1470.   char* buf = readAny(&data,buffer);
  1471.   *s = anyToString(data);
  1472.   freeAny(data);
  1473.   return(buf);
  1474. }
  1475.  
  1476. /*----------------------------------------------------------------------*/
  1477.  
  1478. unsigned long 
  1479. writtenStringSize(tag,s)
  1480. data_tag tag;
  1481. char* s;
  1482. {
  1483.   unsigned long size;
  1484.  
  1485.   if (s == NULL)
  1486.    return(0);
  1487.  
  1488.   size = writtenTagSize(tag);
  1489.   size += writtenCompressedIntSize(size);
  1490.   size += strlen(s);
  1491.   return(size);
  1492. }
  1493.  
  1494. /*----------------------------------------------------------------------*/
  1495.  
  1496. any* 
  1497. longToAny(num)
  1498. long num;
  1499. /* a convienience function */
  1500. {
  1501.   char s[40];
  1502.  
  1503.   sprintf(s,"%ld",num);
  1504.   
  1505.   return(stringToAny(s));
  1506. }
  1507.  
  1508. /*----------------------------------------------------------------------*/
  1509.  
  1510. long
  1511. anyToLong(a)
  1512. any* a;
  1513. /* a convienience function */
  1514. {
  1515.   long num;
  1516.   char* str = NULL;
  1517.   str = anyToString(a);
  1518.   sscanf(str,"%ld",&num);    /* could check the result and return
  1519.                    an error */
  1520.   s_free(str);
  1521.   return(num);
  1522. }
  1523.  
  1524. /*----------------------------------------------------------------------*/
  1525.  
  1526. #define bitsPerByte    8
  1527.  
  1528. bit_map*
  1529. makeBitMap(numBits)
  1530. unsigned long numBits;
  1531. /* construct and return a bitmap with numBits elements */
  1532. {
  1533.   va_list ap;
  1534.   long i,j;
  1535.   bit_map* bm = NULL;
  1536.  
  1537.   va_start(ap,numBits);
  1538.   
  1539.   bm = (bit_map*)s_malloc((size_t)sizeof(bit_map));
  1540.   bm->size = (unsigned long)ceil((double)numBits / bitsPerByte); 
  1541.   bm->bytes = (char*)s_malloc((size_t)bm->size);
  1542.   
  1543.   /* fill up the bits */
  1544.   for (i = 0; i < bm->size; i++) /* iterate over bytes */
  1545.     { char byte = 0;
  1546.       for (j = 0; j < bitsPerByte; j++) /* iterate over bits */
  1547.     { if ((i * bitsPerByte + j) < numBits)
  1548.         { boolean bit = false;
  1549.           bit = (boolean)va_arg(ap,boolean); 
  1550.           if (bit)
  1551.             { byte = byte | (1 << (bitsPerByte - j - 1));
  1552.             }
  1553.         }
  1554.       }
  1555.       bm->bytes[i] = byte;
  1556.     }
  1557.  
  1558.   va_end(ap);
  1559.   return(bm);
  1560. }
  1561.  
  1562.  
  1563. /*----------------------------------------------------------------------*/
  1564.  
  1565. void
  1566. freeBitMap(bm)
  1567. bit_map* bm;
  1568. /* destroy a bit map created by makeBitMap() */
  1569. {
  1570.   s_free(bm->bytes);
  1571.   s_free(bm);
  1572. }
  1573.  
  1574. /*----------------------------------------------------------------------*/
  1575.  
  1576. /* use this routine to interpret a bit map.  pos specifies the bit 
  1577.    number.  bit 0 is the Leftmost bit of the first byte.  
  1578.    Could do bounds checking.
  1579.  */
  1580.  
  1581. boolean
  1582. bitAtPos(pos,bm)
  1583. long pos;
  1584. bit_map* bm;
  1585. {
  1586.   if (pos > bm->size*bitsPerByte)
  1587.     return false;
  1588.   else
  1589.     return((bm->bytes[(pos / bitsPerByte)] & 
  1590.         (0x80>>(pos % bitsPerByte))) ?
  1591.        true : false);
  1592. }
  1593.  
  1594. /*----------------------------------------------------------------------*/
  1595.  
  1596. char*
  1597. writeBitMap(bm,tag,buffer,len)
  1598. bit_map* bm;
  1599. data_tag tag;
  1600. char* buffer;
  1601. long* len;
  1602. /* write a bitmap + type and size info */
  1603. { 
  1604.   return(writeAny((any*)bm,tag,buffer,len));
  1605. }
  1606.  
  1607. /*----------------------------------------------------------------------*/
  1608.  
  1609. char*
  1610. readBitMap(bm,buffer)
  1611. bit_map** bm;
  1612. char* buffer;
  1613. /* read a bitmap + type and size info */
  1614. {
  1615.     char *c;
  1616.  
  1617.  
  1618.  
  1619. c=readAny((any**)bm,buffer);
  1620.  
  1621.   return(c);
  1622. }
  1623.  
  1624. /*----------------------------------------------------------------------*/
  1625.  
  1626. char* 
  1627. writeByte(byte,buf,len)
  1628. unsigned long byte;
  1629. char* buf;
  1630. long* len;
  1631. {
  1632.   CHECK_FOR_SPACE_LEFT(1,len);
  1633.   buf[0] = byte & 0xFF; /* we really only want the first byte */
  1634.   return(buf + 1);
  1635. }
  1636.  
  1637. /*----------------------------------------------------------------------*/
  1638.  
  1639. char* 
  1640. readByte(byte,buf)
  1641. unsigned char* byte;
  1642. char* buf;
  1643. {
  1644.   *byte = buf[0];
  1645.   return(buf + 1);
  1646. }
  1647.  
  1648. /*----------------------------------------------------------------------*/
  1649.  
  1650. char* 
  1651. writeBoolean(flag,buf,len)
  1652. boolean flag;
  1653. char* buf;
  1654. long* len;
  1655. {
  1656.   return(writeByte(flag,buf,len));
  1657. }
  1658.  
  1659. /*----------------------------------------------------------------------*/
  1660.  
  1661. char* 
  1662. readBoolean(flag,buffer)
  1663. boolean* flag;
  1664. char* buffer;
  1665. {
  1666.   unsigned char byte;
  1667.   char* buf = readByte(&byte,buffer);
  1668.   *flag = (byte == true) ? true : false;
  1669.   return(buf);
  1670. }
  1671.  
  1672. /*----------------------------------------------------------------------*/
  1673.  
  1674. char*
  1675. writePDUType(pduType,buf,len)
  1676. pdu_type pduType;
  1677. char* buf;
  1678. long* len;
  1679. /* PDUType is a single byte */
  1680. {
  1681.   return(writeBinaryInteger((long)pduType,(unsigned long)1,buf,len));
  1682. } 
  1683.  
  1684. /*----------------------------------------------------------------------*/
  1685.  
  1686. char*
  1687. readPDUType(pduType,buf)
  1688. pdu_type* pduType;
  1689. char* buf;
  1690. /* PDUType is a single byte */
  1691. {
  1692.   return(readBinaryInteger((long*)pduType,(unsigned long)1,buf));
  1693. } 
  1694.  
  1695. /*----------------------------------------------------------------------*/
  1696.  
  1697. pdu_type
  1698. peekPDUType(buf)
  1699. char* buf;
  1700. /* read the next pdu without advancing the buffer, Note that this 
  1701.    function is to be used on a buffer that is known to contain an
  1702.    APDU.  The pdu_type is written HEADER_LEN bytes into the buffer
  1703.  */
  1704. {
  1705.   pdu_type pdu;
  1706.   readPDUType(&pdu,buf + HEADER_LEN);
  1707.   return(pdu);
  1708. }
  1709.  
  1710. /*----------------------------------------------------------------------*/
  1711.  
  1712. #define BINARY_INTEGER_BYTES    sizeof(long) /* the number of bytes used by
  1713.                         a "binary integer" */
  1714. char*
  1715. writeBinaryInteger(num,size,buf,len)
  1716. long num;
  1717. unsigned long size;
  1718. char* buf;
  1719. long* len;
  1720. /* write out first size bytes of num - no type info
  1721.   XXX should this take unsigned longs instead ???  */
  1722. {
  1723.   long i;
  1724.   char byte;
  1725.  
  1726.   if (size < 1 || size > BINARY_INTEGER_BYTES)
  1727.     return(NULL);        /* error */
  1728.  
  1729.   CHECK_FOR_SPACE_LEFT(size,len);
  1730.  
  1731.   for (i = size - 1; i >= 0; i--)
  1732.     { byte = (char)(num & 255);
  1733.       buf[i] = byte;
  1734.       num = num >> bitsPerByte; /* don't and here */
  1735.     }
  1736.  
  1737.   return(buf + size);
  1738. }
  1739.  
  1740. /*----------------------------------------------------------------------*/
  1741.  
  1742. char*
  1743. readBinaryInteger(num,size,buf)
  1744. long* num;
  1745. unsigned long size;
  1746. char* buf;
  1747. /* read in first size bytes of num - no type info
  1748.   XXX this should take unsigned longs instead !!! */
  1749. {
  1750.   long i;
  1751.   unsigned char byte;
  1752.  
  1753.   if (size < 1 || size > BINARY_INTEGER_BYTES)
  1754.     return(buf);        /* error */
  1755.   *num = 0;
  1756.  
  1757.   for (i = 0; i < size; i++)
  1758.     { byte = buf[i];
  1759.       *num = *num << bitsPerByte;
  1760.       *num += byte;
  1761.     }
  1762.  
  1763.   return(buf + size);
  1764. }
  1765.  
  1766. /*----------------------------------------------------------------------*/
  1767.  
  1768. unsigned long 
  1769. writtenCompressedBinIntSize(num)
  1770. long num;
  1771. /* return the number of bytes needed to represent the value num.
  1772.    currently limited to max of 4 bytes 
  1773.    Only compresses for positive nums - negatives get whole 4 bytes
  1774.  */
  1775. {
  1776.   if (num < 0L)
  1777.     return(4);
  1778.   else if (num < 256L)        /* 2**8 */
  1779.     return(1);
  1780.   else if (num < 65536L)    /* 2**16 */
  1781.     return(2);
  1782.   else if (num < 16777216L)    /* 2**24 */
  1783.     return(3);
  1784.   else
  1785.     return(4);
  1786. }
  1787.  
  1788. /*----------------------------------------------------------------------*/
  1789.  
  1790. char*
  1791. writeNum(num,tag,buffer,len)
  1792. long num;
  1793. data_tag tag;
  1794. char* buffer;
  1795. long* len;
  1796. /* write a binary integer + size and tag info */
  1797. {
  1798.   char* buf = buffer;
  1799.   long size = writtenCompressedBinIntSize(num);
  1800.   
  1801.   if (num == UNUSED)
  1802.     return(buffer);
  1803.     
  1804.   buf = writeTag(tag,buf,len);
  1805.   buf = writeCompressedInteger(size,buf,len); 
  1806.   buf = writeBinaryInteger(num,(unsigned long)size,buf,len); 
  1807.   return(buf);
  1808. }
  1809.  
  1810. /*----------------------------------------------------------------------*/
  1811.  
  1812. char*
  1813. readNum(num,buffer)
  1814. long* num;
  1815. char* buffer;
  1816. /* read a binary integer + size and tag info */
  1817. {
  1818.   char* buf = buffer;
  1819.   data_tag tag;
  1820.   unsigned long size;
  1821.   unsigned long val;
  1822.   
  1823.   buf = readTag(&tag,buf);
  1824.   buf = readCompressedInteger(&val,buf);
  1825.   size = (unsigned long)val;
  1826.   buf = readBinaryInteger(num,size,buf);
  1827.   return(buf);
  1828. }
  1829.  
  1830. /*----------------------------------------------------------------------*/
  1831.  
  1832. unsigned long 
  1833. writtenNumSize(tag,num)
  1834. data_tag tag;
  1835. long num;
  1836. {
  1837.   long dataSize = writtenCompressedBinIntSize(num);
  1838.   long size;
  1839.   
  1840.   size = writtenTagSize(tag); /* space for the tag */
  1841.   size += writtenCompressedIntSize(dataSize); /* space for the size */
  1842.   size += dataSize; /* space for the data */
  1843.   
  1844.   return(size);
  1845. }
  1846.  
  1847. /*----------------------------------------------------------------------*/
  1848.  
  1849. typedef void (voidfunc)();
  1850.  
  1851. void
  1852. doList(list,func)
  1853. void** list;
  1854. voidfunc *func;
  1855. /* call func on each element of the NULL terminated list of pointers */
  1856. {
  1857.   register long i;
  1858.   register void* ptr = NULL;
  1859.   if (list == NULL)
  1860.     return;
  1861.   for (i = 0,ptr = list[i]; ptr != NULL; ptr = list[++i])
  1862.     (*func)(ptr);
  1863. }
  1864.  
  1865. /*----------------------------------------------------------------------*/
  1866.  
  1867. char* 
  1868. writeProtocolVersion(buf,len)
  1869. char* buf;
  1870. long* len;
  1871. /* write a bitmap describing the protocols available */
  1872. {
  1873.   static bit_map* version = NULL;
  1874.  
  1875.   if (version == NULL)
  1876.    { version = makeBitMap((unsigned long)1,true); /* version 1! */
  1877.    }
  1878.     
  1879.   return(writeBitMap(version,DT_ProtocolVersion,buf,len));
  1880. }
  1881.  
  1882. /*----------------------------------------------------------------------*/
  1883.  
  1884. char*
  1885. defaultImplementationID()
  1886. {
  1887.   static char    ImplementationID[] = "TMC";
  1888.   return(ImplementationID);
  1889. }
  1890.  
  1891. /*----------------------------------------------------------------------*/
  1892.  
  1893. char*
  1894. defaultImplementationName()
  1895. {
  1896.   static char ImplementationName[] = "Thinking Machines Corporation Z39.50";
  1897.   return(ImplementationName);
  1898. }
  1899.  
  1900. /*----------------------------------------------------------------------*/
  1901.  
  1902. char*
  1903. defaultImplementationVersion()
  1904. {
  1905.   static char    ImplementationVersion[] = "2.0A";
  1906.   return(ImplementationVersion);
  1907. }
  1908.  
  1909. /*----------------------------------------------------------------------*/
  1910.  
  1911.  
  1912. /*
  1913. **    Routines originally from ZType1.c -- FM
  1914. **
  1915. **----------------------------------------------------------------------*/
  1916. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  1917.    No guarantees or restrictions.  See the readme file for the full standard
  1918.    disclaimer.    
  1919.   
  1920.    3.26.90    Harry Morris, morris@think.com
  1921.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  1922. */
  1923. /*----------------------------------------------------------------------*/
  1924.  
  1925. query_term*
  1926. makeAttributeTerm(use,
  1927.           relation,
  1928.           position,
  1929.           structure,
  1930.           truncation,
  1931.           completeness,
  1932.           term)
  1933. char* use;
  1934. char* relation;
  1935. char* position;
  1936. char* structure;
  1937. char* truncation;
  1938. char* completeness;
  1939. any* term;
  1940. {
  1941.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  1942.  
  1943.   qt->TermType = TT_Attribute;
  1944.  
  1945.   /* copy in the attributes */
  1946.   strncpy(qt->Use,use,ATTRIBUTE_SIZE);
  1947.   strncpy(qt->Relation,relation,ATTRIBUTE_SIZE);
  1948.   strncpy(qt->Position,position,ATTRIBUTE_SIZE);
  1949.   strncpy(qt->Structure,structure,ATTRIBUTE_SIZE);
  1950.   strncpy(qt->Truncation,truncation,ATTRIBUTE_SIZE);
  1951.   strncpy(qt->Completeness,completeness,ATTRIBUTE_SIZE);
  1952.  
  1953.   qt->Term = duplicateAny(term);
  1954.  
  1955.   qt->ResultSetID = NULL;
  1956.  
  1957.   return(qt);
  1958. }
  1959.  
  1960. /*----------------------------------------------------------------------*/
  1961.  
  1962. query_term*
  1963. makeResultSetTerm(resultSet)
  1964. any* resultSet;
  1965. { 
  1966.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  1967.  
  1968.   qt->TermType = TT_ResultSetID;
  1969.  
  1970.   qt->ResultSetID = duplicateAny(resultSet);
  1971.  
  1972.   qt->Term = NULL;
  1973.   
  1974.   return(qt);
  1975. }
  1976.  
  1977. /*----------------------------------------------------------------------*/
  1978.  
  1979. query_term* 
  1980. makeOperatorTerm(operatorCode)
  1981. char* operatorCode;
  1982. {
  1983.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  1984.  
  1985.   qt->TermType = TT_Operator;
  1986.  
  1987.   strncpy(qt->Operator,operatorCode,OPERATOR_SIZE);
  1988.  
  1989.   qt->Term = NULL;
  1990.   qt->ResultSetID = NULL;
  1991.  
  1992.   return(qt);
  1993. }
  1994.  
  1995. /*----------------------------------------------------------------------*/
  1996.  
  1997. void 
  1998. freeTerm(qt)
  1999. query_term* qt;
  2000. {
  2001.   switch (qt->TermType)
  2002.     { case TT_Attribute:
  2003.     freeAny(qt->Term);
  2004.     break;
  2005.       case TT_ResultSetID:
  2006.     freeAny(qt->ResultSetID);
  2007.     break;
  2008.       case TT_Operator:
  2009.     /* do nothing */
  2010.     break;
  2011.       default:
  2012.     panic("Implementation error: Unknown term type %ld",
  2013.           qt->TermType);
  2014.     break;
  2015.       }
  2016.   s_free(qt);
  2017. }
  2018.  
  2019. /*----------------------------------------------------------------------*/
  2020.  
  2021. #define ATTRIBUTE_LIST_SIZE    ATTRIBUTE_SIZE * 6
  2022. #define AT_DELIMITER    " "
  2023.  
  2024. char* 
  2025. writeQueryTerm(qt,buffer,len)
  2026. query_term* qt;
  2027. char* buffer;
  2028. long* len;
  2029. {
  2030.   char* buf = buffer;
  2031.   char attributes[ATTRIBUTE_LIST_SIZE];
  2032.  
  2033.   switch (qt->TermType)
  2034.     { case TT_Attribute:
  2035.     strncpy(attributes,qt->Use,ATTRIBUTE_LIST_SIZE); 
  2036.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  2037.     s_strncat(attributes,qt->Relation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  2038.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  2039.     s_strncat(attributes,qt->Position,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  2040.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  2041.     s_strncat(attributes,qt->Structure,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  2042.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  2043.     s_strncat(attributes,qt->Truncation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  2044.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  2045.     s_strncat(attributes,qt->Completeness,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE);
  2046.     buf = writeString(attributes,DT_AttributeList,buf,len);
  2047.     buf = writeAny(qt->Term,DT_Term,buf,len);
  2048.     break;
  2049.       case TT_ResultSetID:
  2050.     buf = writeAny(qt->ResultSetID,DT_ResultSetID,buf,len);
  2051.     break;
  2052.       case TT_Operator:
  2053.     buf = writeString(qt->Operator,DT_Operator,buf,len);
  2054.     break;
  2055.       default:
  2056.     panic("Implementation error: Unknown term type %ld",
  2057.           qt->TermType);
  2058.     break;
  2059.       }
  2060.  
  2061.   return(buf);
  2062. }
  2063.  
  2064. /*----------------------------------------------------------------------*/
  2065.  
  2066. char* 
  2067. readQueryTerm(qt,buffer)
  2068. query_term** qt;
  2069. char* buffer;
  2070. {
  2071.   char* buf = buffer;
  2072.   char  *attributeList = NULL;
  2073.   char* operator = NULL;
  2074.   any*     term;
  2075.   char* use = NULL;
  2076.   char* relation = NULL;
  2077.   char* position = NULL;
  2078.   char* structure = NULL;
  2079.   char* truncation = NULL;
  2080.   char* completeness;
  2081.   any*    resultSetID = NULL;
  2082.   data_tag tag;
  2083.  
  2084.   
  2085.   tag = peekTag(buffer);
  2086.  
  2087.   switch(tag)
  2088.     { case DT_AttributeList:
  2089.     buf = readString(&attributeList,buf);
  2090.     buf = readAny(&term,buf);
  2091.     use = strtok(attributeList,AT_DELIMITER);
  2092.     relation = strtok(NULL,AT_DELIMITER);
  2093.     position = strtok(NULL,AT_DELIMITER);
  2094.     structure = strtok(NULL,AT_DELIMITER);
  2095.     truncation = strtok(NULL,AT_DELIMITER);
  2096.     completeness = strtok(NULL,AT_DELIMITER);
  2097.     *qt = makeAttributeTerm(use,relation,position,structure,
  2098.                 truncation,completeness,term);
  2099.     s_free(attributeList);
  2100.     freeAny(term);
  2101.     break;
  2102.       case DT_ResultSetID:
  2103.     buf = readAny(&resultSetID,buf);
  2104.     *qt = makeResultSetTerm(resultSetID);    
  2105.     freeAny(resultSetID);
  2106.     break;
  2107.       case DT_Operator:
  2108.     buf = readString(&operator,buf);
  2109.     *qt = makeOperatorTerm(operator);
  2110.     s_free(operator);
  2111.     break;
  2112.       default:
  2113.     REPORT_READ_ERROR(buf);
  2114.     break;
  2115.       }
  2116.   
  2117.   return(buf);
  2118. }
  2119.  
  2120. /*----------------------------------------------------------------------*/
  2121.  
  2122. static unsigned long getQueryTermSize _AP((query_term* qt));
  2123.  
  2124. static unsigned long
  2125. getQueryTermSize(qt)
  2126. query_term* qt;
  2127. /* figure out how many bytes it will take to write this query */
  2128. {
  2129.   unsigned long size;
  2130.   static char attributes[] = "11 22 33 44 55 66"; /* we just need this to 
  2131.                              calculate its written
  2132.                              size */
  2133.  
  2134.   switch (qt->TermType)
  2135.     { case TT_Attribute:
  2136.     size = writtenStringSize(DT_AttributeList,attributes);
  2137.     size += writtenAnySize(DT_Term,qt->Term);
  2138.     break;
  2139.       case TT_ResultSetID:
  2140.     size = writtenAnySize(DT_ResultSetID,qt->ResultSetID);
  2141.     break;
  2142.       case TT_Operator:
  2143.     size = writtenStringSize(DT_Operator,qt->Operator);
  2144.     break;
  2145.       default:
  2146.     panic("Implementation error: Unknown term type %ld",
  2147.           qt->TermType);
  2148.     break;
  2149.       }
  2150.  
  2151.   return(size);
  2152. }
  2153.  
  2154. /*----------------------------------------------------------------------*/
  2155.  
  2156. /* A query is simply a null terminated list of query terms. For 
  2157.    transmission, a query is written into an any which is sent as
  2158.    the user information field. */
  2159.  
  2160. any*
  2161. writeQuery(terms)
  2162. query_term** terms;
  2163. {
  2164.   any* info = NULL;
  2165.   char* writePos = NULL;
  2166.   char* data = NULL;
  2167.   unsigned long size = 0;
  2168.   long remaining = 0;
  2169.   long i;
  2170.   query_term* qt = NULL;
  2171.  
  2172.   if (terms == NULL)
  2173.     return(NULL);
  2174.  
  2175.   /* calculate the size of write buffer */
  2176.   for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i])
  2177.     size += getQueryTermSize(qt);
  2178.  
  2179.   data = (char*)s_malloc((size_t)size);
  2180.  
  2181.   /* write the terms */
  2182.   writePos = data;
  2183.   remaining = size;
  2184.   for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i])
  2185.     writePos = writeQueryTerm(qt,writePos,&remaining);
  2186.  
  2187.   info = makeAny(size,data);
  2188.  
  2189.   return(info);
  2190. }
  2191.  
  2192. /*----------------------------------------------------------------------*/
  2193.  
  2194. query_term**
  2195. readQuery(info)
  2196. any *info;
  2197. {
  2198.   char* readPos = info->bytes;
  2199.   query_term** terms = NULL;
  2200.   query_term* qt = NULL;
  2201.   long numTerms = 0L;
  2202. char tmp[100];
  2203.  
  2204. sprintf(tmp,"readquery: bytes: %ld",info->size);
  2205. log_write(tmp);
  2206.  
  2207.   while (readPos < info->bytes + info->size)
  2208.     { readPos = readQueryTerm(&qt,readPos);
  2209.  
  2210.       if (terms == NULL)
  2211.     { terms = (query_term**)s_malloc((size_t)(sizeof(query_term*)*2));
  2212.     }
  2213.       else
  2214.     { terms = 
  2215.         (query_term**)s_realloc((char*)terms,
  2216.                     (size_t)(sizeof(query_term*)*(numTerms+2)));
  2217.       }
  2218. if(qt==NULL)
  2219.     log_write("qt = null");
  2220.       terms[numTerms++] = qt;
  2221.       terms[numTerms] = NULL;
  2222.     }
  2223.  
  2224.   return(terms);
  2225. }
  2226.  
  2227. /*----------------------------------------------------------------------*/
  2228.  
  2229.  
  2230. /*
  2231. **    Routines originally from panic.c -- FM
  2232. **
  2233. **----------------------------------------------------------------------*/
  2234. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2235.    No guarantees or restrictions.  See the readme file for the full standard
  2236.    disclaimer.
  2237.  
  2238.    Morris@think.com
  2239. */
  2240.  
  2241. /* panic is an error system interface.  On the Mac, it will pop
  2242.  * up a little window to explain the problem.
  2243.  * On a unix box, it will print out the error and call perror()
  2244.  */
  2245.  
  2246. /*----------------------------------------------------------------------*/
  2247.  
  2248. static void exitAction _AP((long error));
  2249.  
  2250. static void
  2251. exitAction(error)
  2252. long error;
  2253. {
  2254.   long i;
  2255.   for (i = 0; i < 100000; i++)
  2256.     ;
  2257.   exit(0);
  2258. }
  2259.  
  2260. /*----------------------------------------------------------------------*/
  2261.  
  2262. #define PANIC_HEADER "Fatal Error:  "
  2263.  
  2264. void
  2265. panic(format)
  2266. char* format;
  2267. {
  2268.   va_list ap;            /* the variable arguments */
  2269.  
  2270.   fprintf(stderr,PANIC_HEADER);
  2271.   va_start(ap, format);        /* init ap */
  2272.   vfprintf(stderr,format,ap);    /* print the contents */
  2273.   va_end(ap);            /* free ap */
  2274.   fflush(stderr);
  2275.   
  2276.   exitAction(0);
  2277. }
  2278.  
  2279. /*----------------------------------------------------------------------*/
  2280.  
  2281.  
  2282. /*
  2283. **    Routines originally from cutil.c -- FM
  2284. **
  2285. **----------------------------------------------------------------------*/
  2286. /* Wide AREA INFORMATION SERVER SOFTWARE    
  2287.    No guarantees or restrictions.  See the readme file for the full standard
  2288.    disclaimer.  
  2289.   
  2290.    3.26.90    Harry Morris, morris@think.com
  2291.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  2292. */
  2293.  
  2294. #include <varargs.h>
  2295.  
  2296.  
  2297. /*----------------------------------------------------------------------*/
  2298.  
  2299. void
  2300. fs_checkPtr(ptr)
  2301. void* ptr;
  2302. /* If the ptr is NULL, give an error */
  2303. { 
  2304.   if (ptr == NULL)
  2305.     panic("checkPtr found a NULL pointer");
  2306. }
  2307.  
  2308. /*----------------------------------------------------------------------*/
  2309.  
  2310. void*
  2311. fs_malloc(size)
  2312. size_t size;
  2313. /* does safety checks and optional accounting */
  2314. { 
  2315.   register void* ptr = NULL;
  2316.  
  2317.   ptr = (void*)calloc((size_t)size,(size_t)1);
  2318.   s_checkPtr(ptr);
  2319.   
  2320.   return(ptr);
  2321. }
  2322.  
  2323. /*----------------------------------------------------------------------*/
  2324.  
  2325. void*
  2326. fs_realloc(ptr,size)
  2327. void* ptr;
  2328. size_t size;
  2329. /* does safety checks and optional accounting 
  2330.    note - we don't know how big ptr's memory is, so we can't ensure
  2331.    that any new memory allocated is NULLed!
  2332.  */
  2333. { 
  2334.   register void* nptr = NULL;
  2335.   
  2336.   if (ptr == NULL)        /* this is really a malloc */
  2337.     return(s_malloc(size));
  2338.     
  2339.   nptr = (void*)realloc(ptr,size);
  2340.   s_checkPtr(ptr);
  2341.    
  2342.   return(nptr);
  2343. }
  2344.  
  2345. /*----------------------------------------------------------------------*/
  2346.  
  2347. void
  2348. fs_free(ptr)
  2349. void* ptr;
  2350. /* does safety checks and optional accounting */
  2351. {
  2352.   if (ptr != NULL)        /* some non-ansi compilers/os's cant handle freeing null */
  2353.     {                /* if we knew the size of this block of memory, we could clear it - oh well */
  2354.       free(ptr);
  2355.     }
  2356. }
  2357.  
  2358. /*----------------------------------------------------------------------*/
  2359.  
  2360. char*
  2361. s_strdup(s)
  2362. char* s;
  2363.  
  2364. /* return a copy of s.  This is identical to the standard library routine
  2365.    strdup(), except that it is safe.  If s == NULL or malloc fails, 
  2366.    appropriate action is taken.
  2367.  */
  2368. {
  2369.   unsigned long len;
  2370.   char* copy = NULL;
  2371.   
  2372.   if (s == NULL)        /* saftey check to postpone stupid errors */
  2373.     return(NULL);
  2374.     
  2375.   len = strlen(s);        /* length of string - terminator */
  2376.   copy = (char*)s_malloc((size_t)(sizeof(char)*(len + 1)));
  2377.   strncpy(copy,s,len + 1);
  2378.   return(copy);
  2379. }
  2380.  
  2381. /*----------------------------------------------------------------------*/
  2382.  
  2383. char*
  2384. fs_strncat(dst,src,maxToAdd,maxTotal)
  2385. char* dst;
  2386.    char* src;
  2387.    size_t maxToAdd;
  2388.    size_t maxTotal;
  2389.  
  2390. /* like strncat, except the fourth argument limits the maximum total 
  2391.    length of the resulting string
  2392.  */
  2393. {
  2394.   size_t dstSize = strlen(dst);
  2395.   size_t srcSize = strlen(src);
  2396.   
  2397.   if (dstSize + srcSize < maxTotal) /* use regular old strncat */
  2398.     return(strncat(dst,src,maxToAdd));
  2399.   else
  2400.     { size_t truncateTo = maxTotal - dstSize - 1;
  2401.       char   saveChar = src[truncateTo];
  2402.       char*  result = NULL;
  2403.       src[truncateTo] = '\0';
  2404.       result = strncat(dst,src,maxToAdd);
  2405.       src[truncateTo] = saveChar;
  2406.       return(result);
  2407.     }
  2408. }
  2409.  
  2410. /*----------------------------------------------------------------------*/
  2411.  
  2412. char char_downcase(long_ch)
  2413. unsigned long long_ch;
  2414. {
  2415.   unsigned char ch = long_ch & 0xFF; /* just want one byte */
  2416.   /* when ansi is the way of the world, this can be tolower */
  2417.   return (((ch >= 'A') && (ch <= 'Z')) ? (ch + 'a' -'A') : ch);
  2418. }
  2419.  
  2420. char *string_downcase(word)
  2421. char *word;
  2422. {
  2423.   long i = 0;
  2424.   while(word[i] != '\0'){
  2425.     word[i] = char_downcase((unsigned long)word[i]);
  2426.     i++;
  2427.   }
  2428.   return(word);
  2429. }
  2430.  
  2431. /*----------------------------------------------------------------------*/
  2432.  
  2433.